#[cfg(test)]
mod chain {
    use std::thread;

    // 在 Rust 中实现 Singleton 的一种纯粹安全的方法是根本不使用全局变量并通过函数参数传递所有内容。
    // 最旧的生存变量是在 main() 开始时创建的对象。
    fn change(global_state: &mut u32) {
        *global_state += 1;
    }

    #[test]
    fn main() {
        let mut global_state = 0u32;
        thread::spawn(move || {
            for i in 1..10 {
                change(&mut global_state);
                println!("spawn 1: {}", global_state)
            }
        });
        for i in 1..5 {
            change(&mut global_state);
            println!("spawn 2: {}", global_state)
        }

        println!("Final state: {}", global_state);
    }
}

#[cfg(test)]
mod lazy {
    use std::sync::Mutex;

    use lazy_static::lazy_static;

    // 在 Rust 中实现 Singleton 的一种纯粹安全的方法是根本不使用全局变量并通过函数参数传递所有内容。
    // 最旧的生存变量是在 main() 开始时创建的对象。
    fn change(global_state: &mut u32) {
        *global_state += 1;
    }


    lazy_static! {
    static ref ARRAY: Mutex<Vec<u8>> = Mutex::new(vec![]);
}

    fn do_a_call() {
        ARRAY.lock().unwrap().push(1);
    }

    #[test]
    fn main() {
        do_a_call();
        do_a_call();
        do_a_call();

        println!("Called {}", ARRAY.lock().unwrap().len());
    }
}

#[cfg(test)]
mod mutex {
    use std::sync::Mutex;

    // Now that Mutex::new is const, you can use global static Mutex locks without needing lazy initialization.
    static ARRAY: Mutex<Vec<i32>> = Mutex::new(Vec::new());

    fn do_a_call() {
        ARRAY.lock().unwrap().push(1);
    }

    #[test]
    fn main() {
        do_a_call();
        do_a_call();
        do_a_call();

        println!("Called {} times", ARRAY.lock().unwrap().len());
    }
}
